home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / progutil / iostream.zoo / src / editbuf.cc next >
C/C++ Source or Header  |  1991-09-22  |  19KB  |  721 lines
  1. //    This is part of the iostream library, providing input/output for C++.
  2. //    Copyright (C) 1991 Per Bothner.
  3. //
  4. //    This library is free software; you can redistribute it and/or
  5. //    modify it under the terms of the GNU Library General Public
  6. //    License as published by the Free Software Foundation; either
  7. //    version 2 of the License, or (at your option) any later version.
  8. //
  9. //    This library is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12. //    Library General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU Library General Public
  15. //    License along with this library; if not, write to the Free
  16. //    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #include "ioprivat.h"
  19. #include "editbuf.h"
  20. #include <stddef.h>
  21. #pragma implementation
  22.  
  23. /* NOTE: Some of the code here is taken from GNU emacs */
  24. /* Hence this file falls under the GNU License! */
  25.  
  26. // Invariants for edit_streambuf:
  27. // An edit_streambuf is associated with a specific edit_string,
  28. // which again is a sub-string of a specific edit_buffer.
  29. // An edit_streambuf is always in either get mode or put mode, never both.
  30. // In get mode, gptr() is the current position,
  31. // and pbase(), pptr(), and epptr() are all NULL.
  32. // In put mode, pptr() is the current position,
  33. // and eback(), gptr(), and egptr() are all NULL.
  34. // Any edit_streambuf that is actively doing insertion (as opposed to
  35. // replacing) // must have its pptr() pointing to the start of the gap.
  36. // Only one edit_streambuf can be actively inserting into a specific
  37. // edit_buffer; the edit_buffer's _writer field points to that edit_streambuf.
  38. // That edit_streambuf "owns" the gap, and the actual start of the
  39. // gap is the pptr() of the edit_streambuf; the edit_buffer::_gap_start pointer
  40. // will only be updated on an edit_streambuf::overflow().
  41.  
  42. int edit_streambuf::truncate()
  43. {
  44.     str->buffer->delete_range(str->buffer->tell((buf_char*)pptr()),
  45.                   str->buffer->tell(str->end));
  46.     return 0;
  47. }
  48.  
  49. #ifdef OLD_STDIO
  50. inline void  disconnect_gap_from_file(edit_buffer* buffer, FILE* fp)
  51. {
  52.     if (buffer->gap_start_ptr != &fp->__bufp)
  53.     return;
  54.     buffer->gap_start_normal = fp->__bufp;
  55.     buffer->gap_start_ptr = &buffer->gap_start_normal;
  56. }
  57. #endif
  58.  
  59. void edit_streambuf::flush_to_buffer(edit_buffer* buffer)
  60. {
  61.     if (pptr() > buffer->_gap_start && pptr() < buffer->gap_end())
  62.     buffer->_gap_start = pptr();
  63. }
  64.  
  65. void edit_streambuf::disconnect_gap_from_file(edit_buffer* buffer)
  66. {
  67. #ifndef OLD_STDIO
  68.     if (buffer->_writer != this) return;
  69.     flush_to_buffer(buffer);
  70.     setp(pptr(),pptr());
  71.     buffer->_writer = NULL;    
  72. #else
  73.     if (buffer->gap_start_ptr != &__bufp)
  74.     return;
  75.     buffer->gap_start_normal = gptr();
  76.     buffer->gap_start_ptr = &buffer->gap_start_normal;
  77. #endif
  78. }
  79.  
  80. buf_index edit_buffer::tell(buf_char *ptr)
  81. {
  82.     if (ptr <= gap_start())
  83.     return ptr - data;
  84.     else
  85.     return ptr - gap_end() + size1();
  86. }
  87.  
  88. #if 0
  89. buf_index buf_cookie::tell()
  90. {
  91.     return str->buffer->tell(file->__bufp);
  92. }
  93. #endif
  94.  
  95. buf_index edit_buffer::tell(edit_mark*mark)
  96. {
  97.     return tell(data + mark->index_in_buffer(this));
  98. }
  99.  
  100. // adjust the position of the gap
  101.  
  102. void edit_buffer::move_gap(buf_offset pos)
  103. {
  104.   if (pos < size1())
  105.     gap_left (pos);
  106.   else if (pos > size1())
  107.     gap_right (pos);
  108. }
  109.  
  110. void edit_buffer::gap_left (int pos)
  111. {
  112.   register buf_char *to, *from;
  113.   register int i;
  114.   int new_s1;
  115.  
  116.   i = size1();
  117.   from = gap_start();
  118.   to = from + gap_size();
  119.   new_s1 = size1();
  120.  
  121.   /* Now copy the characters.  To move the gap down,
  122.      copy characters up.  */
  123.  
  124.   for (;;)
  125.     {
  126.       /* I gets number of characters left to copy.  */
  127.       i = new_s1 - pos;
  128.       if (i == 0)
  129.     break;
  130. #if 0
  131.       /* If a quit is requested, stop copying now.
  132.      Change POS to be where we have actually moved the gap to.  */
  133.       if (QUITP)
  134.     {
  135.       pos = new_s1;
  136.       break;
  137.     }
  138. #endif
  139.       /* Move at most 32000 chars before checking again for a quit.  */
  140.       if (i > 32000)
  141.     i = 32000;
  142.       new_s1 -= i;
  143.       while (--i >= 0)
  144.     *--to = *--from;
  145.     }
  146.  
  147.   /* Adjust markers, and buffer data structure, to put the gap at POS.
  148.      POS is where the loop above stopped, which may be what was specified
  149.      or may be where a quit was detected.  */
  150.   adjust_markers (pos << 1, size1() << 1, gap_size(), data);
  151. #ifndef OLD_STDIO
  152.   _gap_start = data + pos;
  153. #else
  154.   if (gap_start_ptr == &gap_start_normal)
  155.     gap_start_normal = data + pos;
  156. #endif
  157.   __gap_end_pos = to - data;
  158. /*  QUIT;*/
  159. }
  160.  
  161. void edit_buffer::gap_right (int pos)
  162. {
  163.   register buf_char *to, *from;
  164.   register int i;
  165.   int new_s1;
  166.  
  167.   i = size1();
  168.   to = gap_start();
  169.   from = i + gap_end();
  170.   new_s1 = i;
  171.  
  172.   /* Now copy the characters.  To move the gap up,
  173.      copy characters down.  */
  174.  
  175.   while (1)
  176.     {
  177.       /* I gets number of characters left to copy.  */
  178.       i = pos - new_s1;
  179.       if (i == 0)
  180.     break;
  181. #if 0
  182.       /* If a quit is requested, stop copying now.
  183.      Change POS to be where we have actually moved the gap to.  */
  184.       if (QUITP)
  185.     {
  186.       pos = new_s1;
  187.       break;
  188.     }
  189. #endif
  190.       /* Move at most 32000 chars before checking again for a quit.  */
  191.       if (i > 32000)
  192.     i = 32000;
  193.       new_s1 += i;
  194.       while (--i >= 0)
  195.     *to++ = *from++;
  196.     }
  197.  
  198.   adjust_markers ((size1() + gap_size()) << 1, (pos + gap_size()) << 1,
  199.     - gap_size(), data);
  200. #ifndef OLD_STDIO
  201.   _gap_start = data+pos;
  202. #else
  203.   if (gap_start_ptr == &gap_start_normal)
  204.     gap_start_normal = data + pos;
  205. #endif
  206.   __gap_end_pos = from - data;
  207. /*  QUIT;*/
  208. }
  209.  
  210. /* make sure that the gap in the current buffer is at least k
  211.    characters wide */
  212.  
  213. void edit_buffer::make_gap(buf_offset k)
  214. {
  215.   register buf_char *p1, *p2, *lim;
  216.   buf_char *old_data = data;
  217.   int s1 = size1();
  218.  
  219.   if (gap_size() >= k)
  220.     return;
  221.  
  222.   /* Get more than just enough */
  223.   if (buf_size > 1000) k += 2000;
  224.   else k += /*200;*/ 20; // for testing!
  225.  
  226.   p1 = (buf_char *) realloc (data, s1 + size2() + k);
  227.   if (p1 == 0)
  228.     abort(); /*memory_full ();*/
  229.  
  230.   k -= gap_size();            /* Amount of increase.  */
  231.  
  232.   /* Record new location of text */
  233.   data = p1;
  234.  
  235.   /* Transfer the new free space from the end to the gap
  236.      by shifting the second segment upward */
  237.   p2 = data + buf_size;
  238.   p1 = p2 + k;
  239.   lim = p2 - size2();
  240.   while (lim < p2)
  241.     *--p1 = *--p2;
  242.  
  243.   /* Finish updating text location data */
  244.   __gap_end_pos += k;
  245.  
  246. #ifndef OLD_STDIO
  247.   _gap_start = data + s1;
  248. #else
  249.   if (gap_start_ptr == &gap_start_normal)
  250.     gap_start_normal = data + s1;
  251. #endif
  252.  
  253.   /* adjust markers */
  254.   adjust_markers (s1 << 1, (buf_size << 1) + 1, k, old_data);
  255.   buf_size += k;
  256. }
  257.  
  258. /* Add `amount' to the position of every marker in the current buffer
  259.    whose current position is between `from' (exclusive) and `to' (inclusive).
  260.    Also, any markers past the outside of that interval, in the direction
  261.    of adjustment, are first moved back to the near end of the interval
  262.    and then adjusted by `amount'.  */
  263.  
  264. void edit_buffer::adjust_markers(register mark_pointer low,
  265.                  register mark_pointer high,
  266.                  int amount, buf_char *old_data)
  267. {
  268.   register struct edit_mark *m;
  269.   register mark_pointer mpos;
  270.   /* convert to mark_pointer */
  271.   amount <<= 1;
  272.  
  273.   if (_writer)
  274.       _writer->disconnect_gap_from_file(this);
  275.  
  276.   for (m = mark_list(); m != NULL; m = m->chain)
  277.     {
  278.       mpos = m->_pos;
  279.       if (amount > 0)
  280.     {
  281.       if (mpos > high && mpos < high + amount)
  282.         mpos = high + amount;
  283.     }
  284.       else
  285.     {
  286.       if (mpos > low + amount && mpos <= low)
  287.         mpos = low + amount;
  288.     }
  289.       if (mpos > low && mpos <= high)
  290.     mpos += amount;
  291.       m->_pos = mpos;
  292.     }
  293.  
  294.     // Now adjust files
  295.     edit_streambuf *file;
  296.  
  297.     for (file = files; file != NULL; file = file->next) {
  298.     mpos = file->current() - old_data;
  299.     if (amount > 0)
  300.     {
  301.       if (mpos > high && mpos < high + amount)
  302.         mpos = high + amount;
  303.     }
  304.     else
  305.     {
  306.       if (mpos > low + amount && mpos <= low)
  307.         mpos = low + amount;
  308.     }
  309.     if (mpos > low && mpos <= high)
  310.         mpos += amount;
  311.     char* new_pos = data + mpos;
  312.     if (file->is_reading()) {
  313.         file->setg(new_pos, new_pos, new_pos);
  314.         file->setp(NULL, NULL);
  315.     }
  316.     else {
  317.         file->s